#include <iostream>
using namespace std;

class Base {
public:
    virtual void Func1()
    {
        cout << "Base::Func1()" << endl;
    }
    virtual void Func2()
    {
        cout << "Base::Func2()" << endl;
    }

    void Func3()
    {
        cout << "Base::Func3()" << endl;
    }
};

class Derive:public Base{
public:
    virtual void Func1()
    {
        cout << "Derive::Func1()" << endl;
    }
    virtual void Func2()
    {
        cout << "Derive::Func2()" << endl;
    }
    virtual void Func5()
    {
        cout << "Derive::Func5()" << endl;
    }
    void Func3()
    {
        cout << "Derive::Func3()" << endl;
    }

};


//int main()
//{
//    Base b;
//    Derive d;
//
//    //普通调用 ---什么对象调用什么函数
//    // 编译时/静态    绑定
//    //程序在编译阶段，就可以通过此时编译的类的类型，锁定调用的函数
//    Base* ptr = &b;
//    ptr->Func3();
//    ptr = &d;
//    ptr->Func3();
//
//    //多态调用
//    //运行中/动态    绑定
//    //多态调用是一种动态调用，在编译时无法确定调用那个函数(父类或者子类)
//    //因为不管我们指向的这个对象那个是子类还是父类对象，父类指针指向父类，看到的是父类整个对象
//    //指向子类，看到的是子类对象中父类的部分
//    ptr = &b;
//    ptr->Func1();
//    ptr = &d;
//    ptr->Func1();
//
//    return 0;
//}

int main()
{
    int a = 0;
    cout << "栈  " << &a << endl;

    int* p = new int;
    cout << "堆" << p << endl;

    static int c = 0;
    cout << "静态区" << &c << endl;

    const char* str = "hello wrold";
    cout << "常量区/代码区" <<(void *)str<< endl;
    Base be;
    Base* ptr = &be;
    int* ptr2 = (int*)ptr;
    printf("虚表：%p\n", *ptr);
    cout << "虚表" << (void*)*(int*)&be << endl;    //虚表存放再代码区/常量区

    return 0;

}
